/**
 * mobx_config.js
 * MobX配置辅助 - PLM项目专用
 */

// MobX模拟实现
const mockMobx = {
  configure: (options) => {
    console.log('使用模拟MobX配置:', options);
  },
  observable: (obj) => {
    console.log('创建模拟observable');
    return obj;
  },
  action: (fn) => {
    console.log('创建模拟action');
    return fn;
  },
  computed: (fn) => {
    console.log('创建模拟computed');
    return fn;
  },
  autorun: (fn) => { 
    console.log('创建模拟autorun');
    fn(); 
    return () => {
      console.log('清理模拟autorun');
    }; 
  },
  runInAction: (fn) => {
    console.log('执行模拟runInAction');
    return fn();
  }
};

// 尝试导入mobx
let mobx;
try {
  // 使用安全的方式加载MobX
  const requireMobx = function() {
    try {
      // 直接从miniprogram_npm导入
      return require('../../config/path_resolver.js').getFrameworkUtilPath('mobx.js');
    } catch (innerError) {
      console.warn('无法从miniprogram_npm加载MobX，尝试其他路径', innerError);
      
      try {
        // 尝试从npm_config中加载
        const npmConfig = require('../../config/path_resolver.js').getConfigPath('npm_config.js');
        return npmConfig.mobx || mockMobx;
      } catch (configError) {
        console.warn('从npm_config加载MobX失败', configError);
        return null;
      }
    }
  };
  
  mobx = requireMobx();
  
  if (mobx) {
    console.log('成功加载MobX库');
  } else {
    throw new Error('所有加载路径均失败');
  }
} catch (e) {
  console.error('加载MobX库失败，使用模拟实现', e);
  // 使用模拟实现
  mobx = mockMobx;
}

/**
 * 配置MobX
 * 应在应用启动时调用
 */
function configureMobX() {
  try {
    // 允许在任何地方修改状态
    // 注意：这会降低MobX的保护机制，但在快速修复中很有用
    mobx.configure({
      enforceActions: 'never',      // 不强制使用action
      computedRequiresReaction: false,
      reactionRequiresObservable: false,
      observableRequiresReaction: false
    });
    
    console.log('MobX已配置为宽松模式');
  } catch (e) {
    console.error('MobX配置失败', e);
  }
}

/**
 * 创建安全操作
 * 包装action，捕获可能的错误
 * @param {Function} fn - 操作函数
 * @param {string} actionName - 操作名称
 * @returns {Function} 包装后的操作函数
 */
function createSafeAction(fn, actionName = 'unknown') {
  // 用mobx.action包装函数
  let wrappedAction;
  try {
    wrappedAction = mobx.action(fn);
  } catch (e) {
    console.warn(`创建action失败[${actionName}]，使用原始函数`, e);
    wrappedAction = fn;
  }
  
  // 返回包含错误处理的函数
  return function(...args) {
    try {
      return wrappedAction.apply(this, args);
    } catch (error) {
      console.error(`MobX操作错误 [${actionName}]:`, error);
      
      // 尝试加载错误助手
      try {
        const errorHelper = require('../../helpers/page_helper.js');
        errorHelper.handleMobxError(error, actionName);
      } catch (e) {
        console.error('加载错误助手失败', e);
        // 直接显示错误提示
        wx.showToast({
          title: '操作失败，请重试',
          icon: 'none',
          duration: 2000
        });
      }
      
      return null;
    }
  };
}

/**
 * 安全设置observable值
 * 即使在非action中也能工作
 * @param {Object} target - 目标对象
 * @param {string} property - 属性名
 * @param {any} value - 要设置的值
 */
function safeSet(target, property, value) {
  try {
    // 尝试使用runInAction
    try {
      mobx.runInAction(() => {
        target[property] = value;
      });
      return;
    } catch (actionError) {
      console.warn('mobx.runInAction失败，尝试直接设置', actionError);
    }
    
    // 直接设置值
    target[property] = value;
  } catch (error) {
    console.error(`MobX safeSet错误 [${property}]:`, error);
  }
}

module.exports = {
  configureMobX,
  createSafeAction,
  safeSet,
  mobx
}; 